home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Language/OS - Multiplatform Resource Library
/
LANGUAGE OS.iso
/
a_utils
/
expanded.lha
/
test_suite
/
testbasis.C
< prev
next >
Wrap
C/C++ Source or Header
|
1992-03-19
|
5KB
|
215 lines
//
// Linear-Affine-Projective Geometry Package
//
// testbasis.C
//
// $Header$
//
// William J.R. Longabaugh
// University of Washington
//
// Test programs for the linear-affine-projective geometry
// package described in William J.R. Longabaugh, "An Expanded
// System for Coordinate-Free Geometric Programming", Master's
// thesis, University of Washington, 1992.
//
// Copyright (c) 1992, William J.R. Longabaugh
// Copying, use and development for non-commercial purposes permitted.
// All rights for commercial use reserved.
// This software is unsupported and without warranty; it is
// provided "as is".
//
// ***********************************************************************
#include "Lap.h"
#include <math.h>
extern void test1(void);
extern void test2(void);
extern void test3(void);
// ***********************************************************************
int main(void)
{
test1();
test2();
test3();
return (0);
}
// ***********************************************************************
// Build different bases, access elements, use to get coordinates:
void test1(void)
{
cout << "ENTERING TEST1\n";
VSpace v("Test vector space", 3, TRUE);
ASpace a("Test affine space", 2, TRUE);
PSpace p;
p = PSpace("Test projective space", v, a);
// Create different kinds of bases:
VBasis bas = v.StdBasis();
Frame fra = a.StdBasis();
HFrame hfra;
hfra = p.StdBasis();
Vector v1(bas, ScalarList(1.4, 2.3, 5.6));
Vector v2(bas, ScalarList(2.4, 0.3, 9.5));
AVector av1(fra, ScalarList(2.5, 3.6, 0.0));
AVector av2(fra, ScalarList(-4.6, 1.1, 0.0));
APoint a1(fra, ScalarList(3.6, -4.5, 1.0));
PPoint p1(hfra, ScalarList(2.1, 4.3, 7.2));
PPoint p2;
p2 = PPoint(hfra, ScalarList(5.6, 8.7, 1.3));
VBasis b1("test vbasis", v, GeObList(v1, av1, p2));
Frame f1("test frame", a, GeObList(av1, av2, p1));
Simplex s1("test simplex", a, GeObList(p1, a1, p2));
HFrame h1;
h1 = HFrame("test proj frame", p, GeObList(p1, VectorEC(v2), a1, p2));
cout << b1;
cout << f1;
cout << s1;
cout << h1;
// Converting simplices/frames:
Simplex s2(f1);
Frame f2(s1, 2);
cout << s2;
cout << f2;
// Accessing elements of a basis:
GeOb ov = b1[0];
cout << ov;
ov = b1[2];
cout << ov;
GeOb oav = f1[0];
cout << oav;
oav = f1[1];
cout << oav;
GeOb oap = f1[2];
cout << oap;
oap = s1[0];
cout << oap;
oap = s1[2];
cout << oap;
GeOb opp = h1[0];
cout << opp;
opp = h1[3];
cout << opp;
// Using a basis to get coordinates:
ScalarList listo = b1(p2);
cout << listo;
PPoint ptst1 = a1;
listo = f1(ptst1);
cout << listo;
listo = s1(ptst1);
cout << listo;
Vector tst1 = av1;
listo = f1(tst1);
cout << listo;
listo = s1(tst1);
cout << listo;
tst1 = a1;
listo = h1(tst1);
cout << listo;
listo = h1(p2);
cout << listo;
}
// ***********************************************************************
// Build bases using vector and point tuples:
void test2(void)
{
cout << "ENTERING TEST2\n";
VSpace v("Test vector space", 3, TRUE);
ASpace a("Test affine space", TRUE, v);
VSpace t = a.GetSpace(TANGENT);
ASpace ca("Cartesian aspace", SpaceList(a, a, a), FALSE);
VSpace cv1("Cartesian vspace1", SpaceList(v, t, t), FALSE);
VSpace cv2("Cartesian vspace2", SpaceList(t, v, v), FALSE);
VSpace cv3("Cartesian vspace3", SpaceList(v, v), FALSE);
Frame fra = a.StdBasis();
APoint a1(fra, ScalarList(3.6, -4.5, 1.0));
APoint a2(fra, ScalarList(2.5, 7.8, 1.0));
APoint a3(fra, ScalarList(-1.1, 6.3, 1.0));
APoint ptup(ca, GeObList(a1, a2, a3));
Simplex simp("Test tuple simplex", ptup);
cout << simp;
VBasis bas = v.StdBasis();
Vector v1(bas, ScalarList(1.4, 2.3, 5.6));
Vector v2(bas, ScalarList(3.6, -4.5, 0.0));
Vector v3(bas, ScalarList(2.4, 0.3, 0.0));
AVector av1(fra, ScalarList(2.4, 3.3, 0.0));
AVector av2(fra, ScalarList(1.1, 7.8, 0.0));
Vector vtup1(cv1, GeObList(v1, av1, av2));
VBasis vbas1("Test tuple basis 1", vtup1);
cout << vbas1;
Vector vtup2(cv2, GeObList(av1, v1, v2));
VBasis vbas2("Test tuple basis 2", vtup2);
cout << vbas2;
Vector vtup3(cv3, GeObList(v2, v3));
VBasis vbas3("Test tuple basis 3", vtup3);
cout << vbas3;
}
// ***********************************************************************
// Creation of a dual basis:
void test3(void)
{
cout << "ENTERING TEST3\n";
VSpace v("test vspace", 3, TRUE);
VBasis bas = v.StdBasis();
Vector v1(bas, ScalarList(1.4, 2.3, 5.6));
Vector v2(bas, ScalarList(3.6, -4.5, 7.8));
Vector v3(bas, ScalarList(2.4, 0.3, 9.5));
VBasis b1("test basis", v, GeObList(v1, v2, v3));
cout << b1;
VBasis du = b1.Dual();
cout << du;
Vector vd(du, ScalarList(1.4, 2.3, 5.6));
cout << vd;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
cout << b1[i].Apply(du[j]) << " ";
}
cout << "\n";
}
cout << "\n" << vd.Apply(v1) << "\n";
}
// ***********************************************************************